//判断公众号截取code
export const getUrlParam = name => {
	let reg = new RegExp('(^|&)' + name + '=([^&]*)(&|$)');
	let r = window.location.search.substr(1).match(reg);
	if (r != null) {
		return unescape(r[2]);
	}
	return null;
};

/**
 * 格式化日期格式 (用于兼容ios Date对象)
 */
export const formatDate = (time) => {
	// 将xxxx-xx-xx的时间格式，转换为 xxxx/xx/xx的格式 
	return time.replace(/\-/g, "/");
}

/**
 * 对象转URL
 * @param {object} obj
 */
export const urlEncode = (obj = {}) => {
	const result = []
	for (const key in obj) {
		const item = obj[key]
		if (!item) {
			continue
		}
		if (isArray(item)) {
			item.forEach(val => {
				result.push(key + '=' + val)
			})
		} else {
			result.push(key + '=' + item)
		}
	}
	return result.join('&')
}

/**
 * 遍历对象
 */
export const objForEach = (obj, callback) => {
	Object.keys(obj).forEach((key) => {
		callback(obj[key], key)
	});
}

/**
 * 是否在数组内
 */
export const inArray = (search, array) => {
	for (var i in array) {
		if (array[i] == search) return true
	}
	return false
}

/**
 * 对Date的扩展，将 Date 转化为指定格式的String
 * 月(Y)、月(m)、日(d)、小时(H)、分(M)、秒(S) 可以用 1-2 个占位符，
 * 例子：
 * dateFormat('YYYY-mm-dd HH:MM:SS', new Date()) ==> 2020-01-01 08:00:00
 */
export const dateFormat = (fmt, date) => {
	const opt = {
		"Y+": date.getFullYear().toString(), // 年
		"m+": (date.getMonth() + 1).toString(), // 月
		"d+": date.getDate().toString(), // 日
		"H+": date.getHours().toString(), // 时
		"M+": date.getMinutes().toString(), // 分
		"S+": date.getSeconds().toString() // 秒
		// 有其他格式化字符需求可以继续添加，必须转化成字符串
	};
	let ret
	for (let k in opt) {
		ret = new RegExp("(" + k + ")").exec(fmt)
		if (ret) {
			fmt = fmt.replace(ret[1], (ret[1].length == 1) ? (opt[k]) : (opt[k].padStart(ret[1].length, "0")))
		};
	};
	return fmt
}
// 获取几个月前的日期
export const getRecentMonth = (monthNum = 0) => {
	let delta = -monthNum // 5个月前的时间
	let date = new Date()
	date.setMonth(date.getMonth() + delta)
	let month = date.getMonth() + 1
	return {
		year: date.getFullYear(),
		month: month >= 10 ? month : ('0' + month),
	};
}
/**
 * 判断是否为空对象
 * @param {*} object 源对象
 */
export const isEmptyObject = (object) => {
	return Object.keys(object).length === 0
}

/**
 * 判断是否为对象
 * @param {*} object
 */
export const isObject = (object) => {
	return Object.prototype.toString.call(object) === '[object Object]'
}

/**
 * 判断是否为数组
 * @param {*} array
 */
export const isArray = (array) => {
	return Object.prototype.toString.call(array) === '[object Array]'
}

/**
 * 判断是否为空
 * @param {*} object 源对象
 */
export const isEmpty = (value) => {
	if (isArray(value)) {
		return value.length === 0
	}
	if (isObject(value)) {
		return isEmptyObject(value)
	}
	return !value
}

/**
 * 对象深拷贝
 * @param {*} obj 源对象
 */
export const cloneObj = (obj) => {
	let newObj = obj.constructor === Array ? [] : {};
	if (typeof obj !== 'object') {
		return;
	}
	for (let i in obj) {
		newObj[i] = typeof obj[i] === 'object' ? cloneObj(obj[i]) : obj[i];
	}
	return newObj
}

// 节流函数
// 思路： 第一次先设定一个变量true，
// 第二次执行这个函数时，会判断变量是否true，
// 是则返回。当第一次的定时器执行完函数最后会设定变量为flase。
// 那么下次判断变量时则为flase，函数会依次运行。
export const throttle = (fn, delay = 100) => {
	// 首先设定一个变量，在没有执行我们的定时器时为null
	var timer = null
	return () => {
		// 当我们发现这个定时器存在时，则表示定时器已经在运行中，需要返回
		if (timer) return
		timer = setTimeout(() => {
			fn.apply(this, arguments)
			timer = null
		}, delay)
	}
}

// 防抖函数
// 首次运行时把定时器赋值给一个变量， 第二次执行时，
// 如果间隔没超过定时器设定的时间则会清除掉定时器，
// 重新设定定时器， 依次反复， 当我们停止下来时，
// 没有执行清除定时器， 超过一定时间后触发回调函数。
// 参考文档：https://segmentfault.com/q/1010000021145192
export function debounce(fn, delay) {
	let timer
	return function() {
		const that = this
		const _args = arguments // 存一下传入的参数
		if (timer) {
			clearTimeout(timer)
		}
		timer = setTimeout(function() {
			fn.apply(that, _args)
		}, delay)
	}
}


/**
 * 数组交集
 * @param {Array} 数组1
 * @param {Array} 数组2
 * @return {Array}
 */
export const arrayIntersect = (array1, array2) => {
	return array1.filter(val => array2.indexOf(val) > -1)
}
/**
 * 添加千分位
 * @param {Object} value
 */
export const formatThousands = (value) => {
	if (value === undefined || value === null || value == "0") {
		value = "0.00";
	}
	if (!isNaN(value)) {
		value = value + "";
	}
	let re = /\d{1,3}(?=(\d{3})+$)/g;
	let n1 = value.replace(/^(\d+)((\.\d+)?)$/, function(s, s1, s2) {
		return s1.replace(re, "$&,") + s2;
	});
	return n1;
};
/**
 * @description: 加法运算
 * @param {*} arg1
 * @param {*} arg2
 * @param {*} number 展示小数点后位数
 * @return {*}
 */
export function operationAdd(arg1, arg2, number = 4) {
	let l1 = 0,
		l2 = 0,
		m,
		c;
	try {
		l1 = arg1.toString().split(".")[1].length;
	} catch (e) {}
	try {
		l2 = arg2.toString().split(".")[1].length;
	} catch (e) {}
	c = Math.abs(l1 - l2);
	m = Math.pow(10, Math.max(l1, l2));
	if (c > 0) {
		let cm = Math.pow(10, c);
		if (l1 > l2) {
			arg1 = Number(arg1.toString().replace(".", ""));
			arg2 = Number(arg2.toString().replace(".", "")) * cm;
		} else {
			arg1 = Number(arg1.toString().replace(".", "")) * cm;
			arg2 = Number(arg2.toString().replace(".", ""));
		}
	} else {
		arg1 = Number(arg1.toString().replace(".", ""));
		arg2 = Number(arg2.toString().replace(".", ""));
	}
	const sum = (arg1 + arg2) / m;
	let max = 0;
	try {
		max = sum.toString().split(".")[1].length;
	} catch (error) {}
	return toFixedFun(sum, number);
	// return sum.toFixed(number);
	// return max > number ? sum.toFixed(number) : sum;
}

/**
 * @description: 减法运算
 * @param {*} arg1
 * @param {*} arg2
 * @param {*} number 展示小数点后位数
 * @return {*}
 */
export function operationSub(arg1, arg2, number = 4) {
	let l1 = 0,
		l2 = 0,
		m,
		n;
	try {
		l1 = arg1.toString().split(".")[1].length;
	} catch (e) {
		l1 = 0;
	}
	try {
		l2 = arg2.toString().split(".")[1].length;
	} catch (e) {
		l2 = 0;
	}
	m = Math.pow(10, Math.max(l1, l2)); //last modify by deeka //动态控制精度长度
	n = l1 >= l2 ? l1 : l2;
	const sum = (arg1 * m - arg2 * m) / m;
	let max = 0;
	try {
		max = sum.toString().split(".")[1].length;
	} catch (error) {}
	return toFixedFun(sum, number);
	// return sum.toFixed(number);
	// return max > number ? sum.toFixed(number) : sum.toFixed(n);
}

/**
 * @description: 乘法运算
 * @param {*} arg1
 * @param {*} arg2
 * @param {*} number 展示小数点后位数
 * @return {*}
 */
export function operationMul(arg1, arg2, number = 4) {
	let m = 0,
		l1 = 0,
		l2 = 0,
		s1 = arg1.toString(),
		s2 = arg2.toString();
	try {
		m += s1.split(".")[1].length;
		l1 = arg1.toString().split(".")[1].length;
	} catch (e) {
		l1 = 0;
	}
	try {
		m += s2.split(".")[1].length;
		l2 = arg2.toString().split(".")[1].length;
	} catch (e) {
		l2 = 0;
	}
	const sum =
		(Number(s1.replace(".", "")) * Number(s2.replace(".", ""))) /
		Math.pow(10, m);
	let max = 0;
	try {
		max = sum.toString().split(".")[1].length;
	} catch (error) {}
	return toFixedFun(sum, number);
	// return sum.toFixed(number);
	// return max > number ? sum.toFixed(number) : sum;
}

/**
 * @description: 除法运算
 * @param {*} arg1
 * @param {*} arg2
 * @param {*} number 展示小数点后位数
 * @return {*}
 */
export function operationDiv(arg1, arg2, number = 4) {
	let l1 = 0,
		l2 = 0,
		r1,
		r2;
	try {
		l1 = arg1.toString().split(".")[1].length;
	} catch (e) {}
	try {
		l2 = arg2.toString().split(".")[1].length;
	} catch (e) {}
	r1 = Number(arg1.toString().replace(".", ""));
	r2 = Number(arg2.toString().replace(".", ""));
	const sum = (r1 / r2) * Math.pow(10, l2 - l1);
	let max = 0;
	try {
		max = sum.toString().split(".")[1].length;
	} catch (error) {}
	return toFixedFun(sum, number);
	// return sum.toFixed(number);
	// return max > number ? sum.toFixed(number) : sum;
}
/**
 *重写toFixed 解决四舍五入问题
 *
 * @export
 * @param {*} data
 * @param {*} len
 */
export function toFixedFun(data, len = 4) {
	if (len == 4) {
		return toFixedFun2(data);
	}
	const number = Number(data || 0);
	if (isNaN(number) || number >= Math.pow(10, 21)) {
		return number.toString();
	}
	if (typeof len === "undefined" || len === 0) {
		return Math.round(number).toString();
	}
	let result = number.toString();
	const numberArr = result.split(".");

	if (numberArr.length < 2) {
		// 整数的情况
		return padNum(result);
	}
	const intNum = numberArr[0]; // 整数部分
	const deciNum = numberArr[1]; // 小数部分
	const lastNum = deciNum.substr(len, 1); // 最后一个数字

	if (deciNum.length === len) {
		// 需要截取的长度等于当前长度
		return result;
	}
	if (deciNum.length < len) {
		// 需要截取的长度大于当前长度 1.3.toFixed(2)
		return padNum(result);
	}
	// 需要截取的长度小于当前长度，需要判断最后一位数字
	result = `${intNum}.${deciNum.substr(0, len)}`;
	if (parseInt(lastNum, 10) >= 5) {
		// 最后一位数字大于5，要进位
		const times = Math.pow(10, len); // 需要放大的倍数
		let changedInt = Number(result.replace(".", "")); // 截取后转为整数
		changedInt++; // 整数进位
		changedInt /= times; // 整数转为小数，注：有可能还是整数
		result = padNum(`${changedInt}`);
	}
	return result;
	// 对数字末尾加0
	function padNum(num) {
		const dotPos = num.indexOf(".");
		if (dotPos === -1) {
			// 整数的情况
			num += ".";
			for (let i = 0; i < len; i++) {
				num += "0";
			}
			return num;
		} else {
			// 小数的情况
			const need = len - (num.length - dotPos - 1);
			for (let j = 0; j < need; j++) {
				num += "0";
			}
			return num;
		}
	}
}

// 为4时单独处理
function toFixedFun2(data, len = 4) {
	const number = Number(data || 0);
	if (isNaN(number) || number >= Math.pow(10, 21)) {
		return number.toString();
	}
	if (typeof len === "undefined" || len === 0) {
		return Math.round(number).toString();
	}
	let result = number.toString();
	const numberArr = result.split(".");

	if (numberArr.length < 2) {
		// 整数的情况
		return padNum(result, 2);
	}
	const intNum = numberArr[0]; // 整数部分
	const deciNum = numberArr[1]; // 小数部分
	const lastNum = deciNum.substr(len, 1); // 最后一个数字
	// 等于2小于4不管 小于2 补零
	if (deciNum.length < 2) {
		// 需要截取的长度大于当前长度 1.3.toFixed(2)
		return padNum(result, 2);
	}
	if (deciNum.length == 2 || deciNum.length < len) {
		// 需要截取的长度等于当前长度
		return result;
	}

	// 需要截取的长度小于当前长度，需要判断最后一位数字
	result = `${intNum}.${deciNum.substr(0, len)}`;
	if (parseInt(lastNum, 10) >= 5) {
		// 最后一位数字大于5，要进位
		const times = Math.pow(10, len); // 需要放大的倍数
		let changedInt = Number(result.replace(".", "")); // 截取后转为整数
		changedInt++; // 整数进位
		changedInt /= times; // 整数转为小数，注：有可能还是整数
		result = padNum(`${changedInt}`, len);
	}
	return result;
	// 对数字末尾加0
	function padNum(num, count) {
		const dotPos = num.indexOf(".");
		if (dotPos === -1) {
			// 整数的情况
			num += ".";
			for (let i = 0; i < count; i++) {
				num += "0";
			}
			return num;
		} else {
			// 小数的情况
			const need = count - (num.length - dotPos - 1);
			for (let j = 0; j < need; j++) {
				num += "0";
			}
			return num;
		}
	}
}
// 判断公司
export const disposeCompany = (type) => {
	let name = "";
	switch (type) {
		case 1:
			name = "集团";
			break;
		case 111:
			name = "生态";
			break;
		case 112:
			name = "鸿林";
			break;
		case 113:
			name = "环科";
			break;
		case 114:
			name = "环保";
			break;
		case 115:
			name = "技术";
			break;
		default:
			name = "";
			break;
	}
	return name;
};